package com.ardf.common;

import java.util.Map;

/**
 * <p>
 * 实体常量类
 * </p>
 *
 * @author ShiYunHao
 * @since 2025-01-09
 */
public class EntityConstants {
    // 算法表-----------------------------------------------------------
    /**
     * 算法表-种类：无顺序
     */
    public static final Byte ALGORITHM_TYPE_NO_ORDER = 0;
    /**
     * 算法表-种类：有顺序，不能反悔，取第一个站开始算的最长有效子路线
     */
    public static final Byte ALGORITHM_TYPE_ORDER_NO_BACK_FIRST = 1;
    /**
     * 算法表-种类：有顺序，能反悔，取最长有效子路线
     */
    public static final Byte ALGORITHM_TYPE_ORDER_BACK_EFFECTIVE = 2;
    /**
     * 算法表-种类：有顺序，不能反悔，取最长有效子路线
     */
    public static final Byte ALGORITHM_TYPE_ORDER_NO_BACK_EFFECTIVE = 3;
    /**
     * 算法表-种类：接力赛无顺序
     */
    public static final Byte ALGORITHM_TYPE_RELAY_NO_ORDER = 4;
    /**
     * 算法表-种类：快速赛无顺序
     */
    public static final Byte ALGORITHM_TYPE_FAST_NO_ORDER = 5;
    /**
     * 算法表-种类：阳光严格有顺序
     */
    public static final Byte ALGORITHM_TYPE_SUNLIGHT_ORDER = 6;
    /**
     * 算法表-种类：阳光接力严格有顺序
     */
    public static final Byte ALGORITHM_TYPE_SUNLIGHT_RELAY_ORDER = 7;


    public static final Map<Byte, String> ALGORITHM_TYPE_NAME_MAP = Map.of(
            EntityConstants.ALGORITHM_TYPE_NO_ORDER, "无顺序",
            EntityConstants.ALGORITHM_TYPE_ORDER_NO_BACK_FIRST, "有顺序，不能反悔，取第一个站开始算的最长有效子路线",
            EntityConstants.ALGORITHM_TYPE_ORDER_BACK_EFFECTIVE, "有顺序，能反悔，取最长有效子路线",
            EntityConstants.ALGORITHM_TYPE_ORDER_NO_BACK_EFFECTIVE, "有顺序，不能反悔，取最长有效子路线",
            EntityConstants.ALGORITHM_TYPE_RELAY_NO_ORDER, "接力赛无顺序",
            EntityConstants.ALGORITHM_TYPE_FAST_NO_ORDER, "快速赛无顺序",
            EntityConstants.ALGORITHM_TYPE_SUNLIGHT_ORDER, "阳光严格有顺序",
            EntityConstants.ALGORITHM_TYPE_SUNLIGHT_RELAY_ORDER, "阳光接力严格有顺序");

    public static final Map<Byte, String> ALGORITHM_TYPE_DESCRIPTION_MAP = Map.of(
            EntityConstants.ALGORITHM_TYPE_NO_ORDER, """
                    无顺序：<br>
                    规定路线：4-3-2-1<br>
                    实际路线：1-2-3-4<br>
                    有效站数：4<br>
                    解释：因为不按照路线顺序找台，只要找到都算有效站数。
                    有效站数越多、总时间少者为胜。
                    """,
            EntityConstants.ALGORITHM_TYPE_ORDER_NO_BACK_FIRST, """
                    有顺序，取第一站开始算的最长有效子路线（不能反悔）：<br>
                    规定路线：1-2-3-4-5<br>
                    选手路线：1(有效)-3(有效)-2(无效)-3(无效)-4(有效)-5(有效)<br>
                    算法逻辑：从第一位1开始算的有效子路线：1-3-4-5<br>
                    有效路线：1-3-4-5<br>
                    有效站数：4<br>
                    解释：按照规定路线一旦跳过某站点将无法进行二次补救，只能继续
                    打卡规定路线的剩余站点。因此2号站点无效，3号属于重复打卡也无
                    效。极端情况：如果第一个站就打5号站（最后一站）后面都打的站点
                    均无效，那么有效站数只有1站。
                    有效站数越多、总时间少者为胜。
                    """,
            EntityConstants.ALGORITHM_TYPE_ORDER_BACK_EFFECTIVE, """
                    有顺序，取最长子路线（子路线中可以反悔）：<br>
                    规定路线：1-2-3-4-5<br>
                    选手路线：5(无效)-1(有效)-2(有效)-4(无效)-3(有效)-4(有效)-5(有效)<br>
                    算法逻辑：从第一位5开始算的子路线：5；从第二位1开始算的子路线：
                    1-2-3-4-5;从第三位2开始算：2-3-4-5；从第四位4开始算：4-5；从第
                    五位3开始算：3-4-5；从第六为4开始算：4-5；从第七位开始算：5<br>
                    有效子路线：5；1-2-3-4-5；2-3-4-5；4-5；3-4-5<br>
                    最长有效路线：1-2-3-4-5<br>
                    最大有效站数：5<br>
                    解释：只要可以连在一起符合规定路线顺序的子路线都算有效路线，不
                    考虑子路线中间和两边穿插的其它无效站点，取最长有效子路线作为最终成绩。
                    有效站数越多、总时间少者为胜。
                    """,
            EntityConstants.ALGORITHM_TYPE_ORDER_NO_BACK_EFFECTIVE, """
                    有顺序，取最长子路线（子路线中不能反悔）：<br>
                    规定路线：1-2-3-4-5<br>
                    选手路线：5(无效)-1(有效)-2(有效)-4(有效)-3(无效)-4(无效)-5(有效)<br>
                    算法逻辑：从第一位5开始算的子路线：5；从第二位1开始算的子路
                    线：1-2-4-5；从第三位2开始算：2-4-5；从第四位4开始算：4-5；从
                    第五位3开始算：3-4-5；从第六位4开始算：4-5；从第七位5开始算:5;<br>
                    有效子路线：5；1-2-4-5；2-4-5；4-5；3-4-5<br>
                    最长有效路线：1-2-4-5<br>
                    最大有效站数：4<br>
                    解释：选手路线的有效子路线中要符合规定路线顺序并且中间不可以
                    反悔，取最长的有效子路线作为最终成绩。
                    有效站数越多、总时间少者为胜。""",

            EntityConstants.ALGORITHM_TYPE_RELAY_NO_ORDER, """
                    接力赛无顺序的解释：<br>
                    由三名选手组成，每名队员找台数相同，3名选手依次出发。
                    前两位选手打卡规定站数之后必须打交接点(MO)，第三位选手打卡规定站数之后打终点站。
                    每位选手只会计算规定站数不重复的站，后面的舍去。
                    最终成绩按三位选手累计打卡有效站数、总时间少者为胜。
                    """,
            EntityConstants.ALGORITHM_TYPE_FAST_NO_ORDER, """
                    快速赛无顺序的解释：<br>
                    通过控制台(S)和终点信标台(MO)时均须打卡取得记录。在控制
                    台(S)打卡之前寻找的快速区电台无效；如未在控制台(S)打卡，则所
                    找慢速区电台无效；在控制台(S)打卡之后所寻找的慢速区电台无
                    效；未通过信标台(MO)打卡，所找快速区电台无效。
                    有效站数越多、总时间少者为胜。""",
            EntityConstants.ALGORITHM_TYPE_SUNLIGHT_ORDER, """
                    阳光严格有顺序：<br>
                    运动员按规定顺序找台，超时、漏台、台序错误均成绩无效。测向时间少者为胜。
                    """,
            EntityConstants.ALGORITHM_TYPE_SUNLIGHT_RELAY_ORDER, """
                    阳光接力严格有顺序的解释：<br>
                    每名队员找台数相同，3名选手依次出发，第一棒打起点后，按照规定顺序打卡，
                    打卡电台后，到接力区打接力点(MO)，并将指卡交接到第二棒；
                    第二棒接指卡按照规定顺序打卡电台后，再次到接力区打接力点并将指卡交接到最后一棒。
                    最后一棒找完电台后到终点打卡，总时间少者为胜。
                    """);

    /**
     * 算法表-状态：已商定，未设非最终
     */
    public static final Byte ALGORITHM_STATUS_AGREED_NO_FINAL = 0;
    /**
     * 算法表-状态：已商定，已设最终
     */
    public static final Byte ALGORITHM_STATUS_AGREED_FINAL = 1;
    /**
     * 算法表-状态：未商定，未设非最终
     */
    public static final Byte ALGORITHM_STATUS_NO_AGREED_NO_FINAL = 2;
    /**
     * 算法表-状态：未商定，已设最终
     */
    public static final Byte ALGORITHM_STATUS_NO_AGREED_FINAL = 3;

    // 选手表-----------------------------------------------------------
    /**
     * 选手表-性别：男
     */
    public static final String ATHLETE_GENDER_MALE = "男";
    /**
     * 选手表-性别：女
     */
    public static final String ATHLETE_GENDER_FEMALE = "女";

    // 选手队伍表---------------------------------------------------------
    /**
     * 选手队伍表-替补状态：否
     */
    public static final String ATHLETETEAM_SUBSTITUTE_NO = "否";
    /**
     * 选手队伍表-替补状态：是
     */
    public static final String ATHLETETEAM_SUBSTITUTE_YES = "是";
    // 赛事表---------------------------------------------------------
    /**
     * 赛事表-进度条：开始标识
     */
    public static final Byte COMPETITION_PROGRESS_START = 0;
    /**
     * 赛事表-进度条：结束标识
     */
    public static final Byte COMPETITION_PROGRESS_END = 6;

    // 成绩信息表---------------------------------------------------------
    /**
     * 成绩信息表-成绩状态：无效
     */
    public static final Byte GRADE_STATUS_NO = 0;
    /**
     * 成绩信息表-成绩状态：有效
     */
    public static final Byte GRADE_STATUS_YES = 1;

    // 项目表-----------------------------------------------------------
    /**
     * 项目表-类型：短距离
     */
    public static final Byte PROJECT_TYPE_SHORT = 0;
    /**
     * 项目表-类型：中距离
     */
    public static final Byte PROJECT_TYPE_MEDIUM = 1;
    /**
     * 项目表-类型：标准距离
     */
    public static final Byte PROJECT_TYPE_STANDARD = 2;
    /**
     * 项目表-类型：快速
     */
    public static final Byte PROJECT_TYPE_FAST = 3;
    /**
     * 项目表-类型：阳光测向
     */
    public static final Byte PROJECT_TYPE_SUNLIGHT = 4;
    /**
     * 项目表-频率/波长：80m
     */
    public static final Byte PROJECT_FREQUENCY_80m = 0;
    /**
     * 项目表-频率/波长：2m
     */
    public static final Byte PROJECT_FREQUENCY_2m = 1;
    /**
     * 项目表-种类：个人
     */
    public static final Byte PROJECT_CATEGORY_PERSON = 0;
    /**
     * 项目表-种类：接力
     */
    public static final Byte PROJECT_CATEGORY_RELAY = 1;

    public static final Map<Byte, String> PROJECT_TYPE_STRING_MAP = Map.of(EntityConstants.PROJECT_TYPE_FAST, "快速",
            EntityConstants.PROJECT_TYPE_MEDIUM, "中距离",
            EntityConstants.PROJECT_TYPE_SHORT, "短距离",
            EntityConstants.PROJECT_TYPE_SUNLIGHT, "阳光测向",
            EntityConstants.PROJECT_TYPE_STANDARD, "标准距离");
    public static final Map<Byte, String> PROJECT_FREQUENCY_STRING_MAP = Map.of(EntityConstants.PROJECT_FREQUENCY_2m, "2m",
            EntityConstants.PROJECT_FREQUENCY_80m, "80m");
    public static final Map<Byte, String> PROJECT_CATEGORY_STRING_MAP = Map.of(EntityConstants.PROJECT_CATEGORY_PERSON, "个人",
            EntityConstants.PROJECT_CATEGORY_RELAY, "接力");

    // 签到表-----------------------------------------------------------
    /**
     * 签到表-签到状态：未签到
     */
    public static final String SIGNIN_STATUS_NO = "否";
    /**
     * 签到表-签到状态：已签到
     */
    public static final String SIGNIN_STATUS_YES = "是";
}
